The present invention relates to state-free systems and in particular to means for handling error details in such state-free systems.
If a system is referred to as operating in an environment which has `state`, this means that the system retains information about the most recent event (or a number of most recent events) that occurred in the system, and the manner in which a subsequent event is processed depends upon that retained information. If a user wishes to determine which event happened most recently, the information can be recalled readily by means of special calls provided within the system. However if the user is performing complex functions on the system such that several different jobs are being processed during the same period of time, then isolating events resulting from one particular job is difficult. Similarly when several users are using the system simultaneously the events arising from the actions of one particular user will not be isolated from events resulting from the other users' actions. This causes problems if a user wishes to analyse the events that have occurred due to his interaction with the system.
To overcome this problem `State-free` systems were developed. They are designed to enable multiple users to work independently in an environment where they are completely unaware of other simultaneous users. Further, they enable a single user to run a complex program without any `side effects` arising that might cause interaction between different parts of the user's program. However, although systems have been developed which create and manipulate sets of data, hereafter referred to as `objects`, in a state-free environment, there has remained a problem of how to deal with errors in a state-free manner.
Typically prior art systems have recorded errors in error stacks. An error stack is a region of memory having a plurality of addressable locations. These locations are written to sequentially as errors occur and a reference pointer keeps track of the last location written to. Hence an error stack is not state-free. The error stack can be interrogated by special calls entered by the user but the errors are merely read out in sequential order, the most recent error being read out first, In other words the errors are held in a first-in-first-out queue. An alternative ways of handling the errors is to only retain details of the last error, i.e. to have an error stack with just one addressable location.